# -*- coding: Latin-1 -*-
#!/usr/bin/env python
'''
Created on 24/11/2011

@author: nmedina
'''
import Funciones
import Seguridad
import WebServices
import Excepciones.Genericas
class BuscarArticulos(Funciones.Fn.Paginacion):
    def __init__(self,mSeguridad):
        self.__security = Seguridad.seguridadstock.Manejador()
        self.__security = mSeguridad
        self.__ArticulosResultado = {}
        Funciones.Fn.Paginacion.__init__(self)
        self.__IdGrupo = self.__security.getPerfilActual()
        self.__IdFamiliaArticulo = -1
        self.__IdTipoArticulo = -1
        self.__Modelo = ""
        self.__Fabricante = ""
        self.__NroSerie = ""
    def getNroSerie(self):
        return self.__NroSerie
    def setNroSerie(self, value):
        self.__NroSerie = value
    def getIdGrupo(self):
        return self.__IdGrupo
    def getIdFamiliaArticulo(self):
        return self.__IdFamiliaArticulo
    def getIdTipoArticulo(self):
        return self.__IdTipoArticulo
    def getModelo(self):
        return self.__Modelo
    def getFabricante(self):
        return self.__Fabricante
    def setIdGrupo(self, value):
        self.__IdGrupo = value
    def setIdFamiliaArticulo(self, value):
        self.__IdFamiliaArticulo = value
    def setIdTipoArticulo(self, value):
        self.__IdTipoArticulo = value
    def setModelo(self, value):
        self.__Modelo = value
    def setFabricante(self, value):
        self.__Fabricante = value
    def Setear(self):
        self.__IdFamiliaArticulo = -1
        self.__IdTipoArticulo = -1
        self.__Modelo = ""
        self.__Fabricante = ""
        self.__ArticulosResultado.clear()
    
    def __SetearRequiereNroSerie(self,mrequiere,mtipo = 1):
        if mrequiere == True and mtipo == 1:
            return "si"
        elif mrequiere == "True" and mtipo == 2:
            return True
        elif mtipo == 2:
            return False
        elif mtipo == 1:
            return "no"
        
    def __BuscarArticulos(self):
        self.__ArticulosResultado.clear()
        buscar = True
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos())                         
        Parametros = {1:("Id_GrupoStock",str(self.getIdGrupo()))
                        ,2:("Id_GrupoArticulo",str(self.getIdFamiliaArticulo()))
                        ,3:("Id_TipoArticulo",str(self.getIdTipoArticulo()))
                        ,4:("Fabricante",str(self.getFabricante()))
                        ,5:("Modelo" ,str(self.getModelo()))
                        ,6:("PageSize",str(self.getPageSize()))
                        ,7:("PageNumber",str(self.getPaginaActual()))
                        ,8:("TipoRespuesta","Python")}
        
        if WebService.Enviar("SELECT_BusquedaArticulos_Reducida"
                            , "www.osplad.org.ar", Parametros)== True:
            if WebService.Count()!= 0 :
                while WebService.BOF()==False and WebService.EOF()==False:
                    if buscar == True:
                        self.setCantRegistros(int(WebService.Fields("TotalRegistros")))
                        buscar = False
                    lresultado = ResultadoArticulo()
                    lresultado.setId(int(WebService.Fields("Id")))
                    lresultado.setTipoArticulo(WebService.Fields("TipoArticulo"))
                    lresultado.setFabricante(WebService.Fields("Fabricante")) 
                    lresultado.setModelo(WebService.Fields("Modelo"))
                    lresultado.setDescripcionArticulo(WebService.Fields("DescripcionArticulo"))
                    lresultado.setRequiereNroDeSerie(self.__SetearRequiereNroSerie(WebService.Fields("RequiereNroSerie"),2))
                    lresultado.setStockMinimo(int(WebService.Fields("StockMinimo"))) 
                    self.__ArticulosResultado[int(WebService.Fields("Id"))] = lresultado
                    WebService.MoveNext()
                return True
            else:
                raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                            "BuscarArticulos"
                            , "__Buscar"
                            , "No se encotraron Articulos")
    def getResultado(self):
        mresultado = {}
        lresultado = ResultadoArticulo()
        for key in self.__ArticulosResultado:
           lresultado = self.__ArticulosResultado[key]
           mresultado[key]= (lresultado.getTipoArticulo(),lresultado.getFabricante()
                             ,lresultado.getModelo(),lresultado.getDescripcionArticulo()
                             ,self.__SetearRequiereNroSerie(lresultado.getRequiereNroDeSerie()))
        return mresultado
    def getArticulo(self,mId):
        if self.__ArticulosResultado.has_key(mId)== True:
            return self.__ArticulosResultado[mId]
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                    ""
                    , ""
                    , "no se encontro el id del articulo")
    def Buscar(self):
        self.setPaginaActual(1)
        if self.__BuscarArticulos()== True:
            return self.getResultado()
        else:
            return False

    def BuscarPaginaSiguiente(self):
        if self.PuedeIrAPaginaSiguiente()== True:
            self.IrPaginaSiguiente()
            if self.__BuscarArticulos()== True:
                return self.getResultado()
            else:
                return False
    def BuscarPaginaAnterior(self):
        if self.PuedeIrAPaginaAnterior()== True:
            self.IrPaginaAnterior()
            if self.__BuscarArticulos()== True:
                return self.getResultado()
            else:
                return False
            
class BuscarProveedor(Funciones.Fn.Paginacion):
    def __init__(self,mSeguridad):
        self.__security = Seguridad.seguridadstock.Manejador()
        self.__security = mSeguridad
        self.__ProveedoresResultado = {}
        Funciones.Fn.Paginacion.__init__(self)
        self.__Cuil = ""
        self.__Nombre = ""
    def getCuil(self):
        return self.__Cuil
    def getNombre(self):
        return self.__Nombre
    def setCuil(self, value):
        self.__Cuil = value
    def setNombre(self, value):
        self.__Nombre = value
    def Setear(self):
        self.__Cuil = ""
        self.__Nombre = ""
        self.__ArticulosResultado.clear()
    def __BuscarProveedor(self):
        self.__ProveedoresResultado.clear()
        buscar = True
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos())                         
        Parametros = {1:("Cuit",str(self.getCuil()))
                        ,2:("Nombre",str(self.getNombre()))
                        ,3:("PageNumber",str(self.getPaginaActual()))
                        ,4:("PageSize",str(self.getPageSize()))
                        ,5:("TipoRespuesta" ,"Python")
                        }
        
        if WebService.Enviar("SELECT_BuscarProveedor_Paginada"
                            , "www.osplad.org.ar", Parametros)== True:
            if WebService.Count()!= 0 :
                while WebService.BOF()==False and WebService.EOF()==False:
                    if buscar == True:
                        self.setCantRegistros(int(WebService.Fields("CantRegistros")))
                        buscar = False
                    lresultado = ResultadoProveedor()
                    lresultado.setId(int(WebService.Fields("IdProveedor")))
                    lresultado.setCuil(WebService.Fields("Cuit"))
                    lresultado.setNombre(WebService.Fields("Nombre"))
                    lresultado.setRazonSocial(WebService.Fields("RazonSocial"))
                    lresultado.setDireccion(WebService.Fields("Direccion"))
                    lresultado.setTelefonos(WebService.Fields("Telefonos"))
                    lresultado.setLocalidad(WebService.Fields("Localidad"))
                    self.__ProveedoresResultado[int(WebService.Fields("IdProveedor"))] = lresultado
                    WebService.MoveNext()
                return True
            else:
                raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                            "BuscarProveedor"
                            , "__Buscar"
                            , "No se encotraron Articulos")
    def getProveedor(self,mId):
        if self.__ProveedoresResultado.has_key(mId)== True:
            return self.__ProveedoresResultado[mId]
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                ""
                , ""
                , "Id proveedor no encontrado")
    def getResultado(self):
        lresultado = ResultadoProveedor()
        mresultado = {}
        for key in self.__ProveedoresResultado:
            lresultado = self.__ProveedoresResultado[key]
            mresultado[key]= (lresultado.getCuil(),lresultado.getNombre(),lresultado.getRazonSocial()
                              ,lresultado.getDireccion(),lresultado.getTelefonos(),lresultado.getLocalidad())
        return mresultado
    def Buscar(self):
        self.setPaginaActual(1)
        if self.__BuscarProveedor()== True:
            return self.getResultado()
        else:
            return False

    def BuscarPaginaSiguiente(self):
        if self.PuedeIrAPaginaSiguiente()== True:
            self.IrPaginaSiguiente()
            if self.__BuscarProveedor()== True:
                return self.getResultado()
            else:
                return False
    def BuscarPaginaAnterior(self):
        if self.PuedeIrAPaginaAnterior()== True:
            self.IrPaginaAnterior()
            if self.__BuscarProveedor()== True:
                return self.getResultado()
            else:
                return False 
            
BUSCAR_ARTICULO_SALIDA_CARACTERISTICAS = 4
BUSCAR_ARTICULO_SALIDA_NORMAL = 3
         
class BuscarArticulosEnstock(Funciones.Fn.Paginacion):
    def __init__(self,mSeguridad):
        self.__security = Seguridad.seguridadstock.Manejador()
        self.__security = mSeguridad
        Funciones.Fn.Paginacion.__init__(self)
        self.__ArticulosResultado = {}
        self.__TipoSalida = BUSCAR_ARTICULO_SALIDA_NORMAL
        self.__IdGrupo = self.__security.getPerfilActual()
        self.__IdFamiliaArticulo = -1
        self.__IdTipoArticulo = -1
        self.__Fabricante = ""
        self.__Modelo = ""
        self.__TextoBuscado = ""
        self.__BuscarDescripcion = False
        self.__BuscarCaracteristica = False
        self.__EnStock = False
        self.setPageSize(10)
        self.setPaginaActual(1)
    def getTipoSalida(self):
        return self.__TipoSalida
    def getIdGrupo(self):
        return self.__IdGrupo
    def getIdFamiliaArticulo(self):
        return self.__IdFamiliaArticulo
    def getIdTipoArticulo(self):
        return self.__IdTipoArticulo
    def getFabricante(self):
        return self.__Fabricante
    def getModelo(self):
        return self.__Modelo
    def getTextoBuscado(self):
        return self.__TextoBuscado
    def getBuscarDescripcion(self):
        return self.__BuscarDescripcion
    def getBuscarCaracteristica(self):
        return self.__BuscarCaracteristica
    def getEnStock(self):
        if self.__EnStock== True:
            return 1
        else:
            return 0
    def setTipoSalida(self, value):
        self.__TipoSalida = value
    def setIdGrupo(self, value):
        self.__IdGrupo = value
    def setIdFamiliaArticulo(self, value):
        self.__IdFamiliaArticulo = value
    def setIdTipoArticulo(self, value):
        self.__IdTipoArticulo = value
    def setFabricante(self, value):
        self.__Fabricante = value
    def setModelo(self, value):
        self.__Modelo = value
    def setTextoBuscado(self, value):
        self.__TextoBuscado = value
    def setBuscarDescripcion(self, value):
        self.__BuscarDescripcion = value
        if value == True:
            self.setTipoSalida(BUSCAR_ARTICULO_SALIDA_NORMAL)
    def setBuscarCaracteristica(self, value):
        self.__BuscarCaracteristica = value
        if value == True:
            self.setTipoSalida(BUSCAR_ARTICULO_SALIDA_CARACTERISTICAS)
    def setEnStock(self, value):
        self.__EnStock = value

    
    def __DeterminarNivelDeStock(self,StockActual,StockMinimo):
        self.SetMetodo("__DeterminarNivelDeStock")
        self.AddSeguimientoCodigo()
        if StockMinimo == "":
            StockMinimo = "0"
        if StockActual != "":
            if int(StockActual) > int(StockMinimo):
                return 'Stock Alto'
            elif int(StockActual) <= int(StockMinimo)and int(StockActual)>0:
                return "Stock Bajo"
            else:
                return "Sin Stock"
        else:
            return "Sin Stock"

            
    def __BuscarArticulos(self):
        self.__ArticulosResultado.clear()
        buscar = True
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos())
                                  
        Parametros = {1:("Id_GrupoStock",str(self.__security.getPerfilActual()))
                        ,2:("Id_GrupoArticulo",str(self.getIdFamiliaArticulo()))
                        ,3:("Id_TipoArticulo",str(self.getIdTipoArticulo()))
                        ,4:("Fabricante",str(self.getFabricante()))
                        ,5:("Modelo" ,str(self.getModelo()))
                        ,6:("TextoABuscar",str(self.getTextoBuscado()))
                        ,7:("BuscarEn",str(self.getTipoSalida()))
                        ,8:("EnStock" ,str(self.getEnStock()))
                        ,9:("PageSize",str(self.getPageSize()))
                        ,10:("PageNumber",str(self.getPaginaActual()))
                        ,11:("TipoRespuesta","Python")}
        if WebService.Enviar("SELECT_Busqueda_Generica"
                            , "www.osplad.org.ar", Parametros)== True:
            if WebService.Count()!= 0 :
                if self.getBuscarCaracteristica() == False:
                    self.__TipoSalida = BUSCAR_ARTICULO_SALIDA_NORMAL
                    while WebService.BOF()==False and WebService.EOF()==False:
                        if buscar == True:
                            self.setCantRegistros(int(WebService.Fields("TOTALREGISTROS")))
                            buscar = False
                        larticulo = ResultadoArticulo()  
                        larticulo.setId(int(WebService.Fields("ID_Articulo")))
                        larticulo.setTipoArticulo(WebService.Fields("CODIGOTIPOARTICULO"))
                        larticulo.setFabricante(WebService.Fields("NOMBREFABRICANTE"))
                        larticulo.setModelo(WebService.Fields("Modelo"))
                        larticulo.setDescripcionArticulo(WebService.Fields("Descripcion"))
                        larticulo.setEnStock(int(WebService.Fields("EnStock")))
                        larticulo.setNivelStock(self.__DeterminarNivelDeStock(
                                                        WebService.Fields("EnStock")
                                                        , WebService.Fields("StockMinimo")))
                        larticulo.setDisponible(int(WebService.Fields("Disponible")))
                        
                        self.__ArticulosResultado[larticulo.getId()] = larticulo
                        WebService.MoveNext()
                elif self.getBuscarCaracteristica() == True:
                    self.__TipoSalida = BUSCAR_ARTICULO_SALIDA_CARACTERISTICAS
                    if buscar == True:
                        self.setCantRegistros(int(WebService.Fields("TOTALREGISTROS")))
                        buscar = False
                    while WebService.BOF()==False and WebService.EOF()==False:
                        larticulo = ResultadoArticulo()
                        larticulo.setId(int(WebService.Fields("ID_Articulo")))
                        larticulo.setTipoArticulo(WebService.Fields("CODIGOTIPOARTICULO"))
                        larticulo.setFabricante(WebService.Fields("NOMBREFABRICANTE"))
                        larticulo.setModelo(WebService.Fields("Modelo")) 
                        larticulo.setEnStock(int(WebService.Fields("EnStock")))
                        larticulo.setNivelStock(
                        self.__DeterminarNivelDeStock(
                        WebService.Fields("EnStock")
                        , WebService.Fields("StockMinimo")))
                        larticulo.setDisponible(int(WebService.Fields("Disponible")))
                        larticulo.AgregarCaracteristica(WebService.Fields("CARACTERISTICA")
                                                        , WebService.Fields("VALOR"))
                        if not self.__ArticulosResultado.has_key(larticulo.getId()):
                            self.__ArticulosResultado[larticulo.getId()] = larticulo
                        else:
                            self.__ArticulosResultado[
                            larticulo.getId()].AgregarCaracteristica(WebService.Fields("CARACTERISTICA")
                                                        , WebService.Fields("VALOR"))
                        WebService.MoveNext()
                return True
            else:
                raise Excepciones.Genericas.Consulta_Sin_Resultados(
                            ""
                            , ""
                            , "No se encotraron Articulos")
    def getArticulo(self,mId):
        if self.__ArticulosResultado.has_key(mId)== True:
            return self.__ArticulosResultado[mId]
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "", "", "Id articulo no encontrado")
    def getListado(self):
        mlistado = {}
        if self.getTipoSalida() == BUSCAR_ARTICULO_SALIDA_NORMAL:
            larticulo = ResultadoArticulo()
            for key in self.__ArticulosResultado:
                larticulo = self.__ArticulosResultado[key]
                lista = (larticulo.getTipoArticulo(),larticulo.getFabricante()
                         ,larticulo.getModelo(),larticulo.getDescripcionArticulo()
                         ,str(larticulo.getEnStock()),str(larticulo.getDisponible())
                         ,larticulo.getNivelStock()
                         )
                mlistado[larticulo.getId()]= lista
        elif self.getTipoSalida() == BUSCAR_ARTICULO_SALIDA_CARACTERISTICAS:
            larticulo = ResultadoArticulo()
            for key in self.__ArticulosResultado:
                larticulo = self.__ArticulosResultado[key]
                lista = (larticulo.getTipoArticulo(),larticulo.getFabricante()
                         ,larticulo.getModelo(),larticulo.getCaracteristicas_str()
                         ,str(larticulo.getEnStock()),str(larticulo.getDisponible())
                         ,larticulo.getNivelStock())
                mlistado[larticulo.getId()]= lista
                
        return mlistado
    def refrescar(self):
        if self.__BuscarArticulos()== True:
            return self.getListado()
        else:
            return False
    def Buscar(self):
        self.setPaginaActual(1)
        if self.__BuscarArticulos()== True:
            return self.getListado()
        else:
            return False

    def BuscarPaginaSiguiente(self):
        if self.PuedeIrAPaginaSiguiente()== True:
            self.IrPaginaSiguiente()
            if self.__BuscarArticulos()== True:
                return self.getListado()
            else:
                return False
    def BuscarPaginaAnterior(self):
        if self.PuedeIrAPaginaAnterior()== True:
            self.IrPaginaAnterior()
            if self.__BuscarArticulos()== True:
                return self.getListado()
            else:
                return False
    def __CrearColumn(self):
        self.SetMetodo("__CrearColumn")
        self.AddSeguimientoCodigo()
        if self.__TipoSalida == BUSCAR_ARTICULO_SALIDA_NORMAL :
            self.__Colum = {0:'Tipo De Articulo'
                                ,1:'Fabricante'
                                ,2:'Modelo'
                                ,3:'Descripcion'
                                ,4:'En Stock'
                                ,5:'Disponible'
                                ,6:'Estado'}
            return True
        elif self.__TipoSalida == BUSCAR_ARTICULO_SALIDA_CARACTERISTICAS:
            self.__Colum = {0:'Tipo De Articulo'
                                ,1:'Fabricante'
                                ,2:'Modelo'
                                ,3:'Coincidencia'
                                ,4:'En Stock'
                                ,5:'Disponible'
                                ,6:'Estado'}
            return True

    def getListadoColumnas(self):
        if self.__CrearColumn()== True:
            return self.__Colum
        
class BuscarFabricantes(Funciones.Fn.Paginacion):
    def __init__(self,lsecurity):
        Funciones.Fn.Paginacion.__init__(self)
        self.__security = lsecurity
        self.__Resultado = {}
        self.__Nombre = ""
        self.__Descripcion = ""
        
    def setNombre(self,nombre = ""):
        self.__Nombre = nombre
    def setDescripcion(self,descripcion = ""):
        self.__Descripcion = descripcion
    def getNombre(self):
        return self.__Nombre
    def getDescripcion(self):
        return self.__Descripcion
    def getListado_fabricantes(self):
        return self.__Resultado
    def getListado_Fabricante_lv(self):
        dicc ={}
        for key in self.__Resultado:
            fabricante = ResultadoFabricantes()
            fabricante = self.__Resultado[key]
            dicc[fabricante.getId()]= (fabricante.getNombre(),fabricante.getDescripcion())
        return dicc
    def getfabricante(self,lkey):
        if self.__Resultado.has_key(lkey)==True:
            return self.__Resultado[lkey]
        else:
            raise KeyError , "Fabricante no encontrado"
    def __Buscar(self):
        self.__Resultado.clear()
        buscar = True
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos()) 
                             
        Parametros = {1:("Nombre",str(self.getNombre()))
                        ,2:("Descripcion",str(self.getDescripcion()))
                        ,3:("PageNumber",str(self.getPaginaActual()))
                        ,4:("PageSize",str(self.getPageSize()))
                        ,5:("TipoRespuesta",'Python')
                    }
            
            
        if WebService.Enviar("SELECT_BusquedaFabricantes_Paginada"
                            , "www.osplad.org.ar", Parametros)== True:
            if WebService.Count()!= 0 :
                while WebService.BOF()==False and WebService.EOF()==False:
                    if buscar == True:
                        self.setCantRegistros(int(WebService.Fields("CantRegistros")))
                        buscar = False
                    resultado = ResultadoFabricantes(WebService.Fields("IdFabricante")
                                                     ,WebService.Fields("Nombre")
                                                     ,WebService.Fields("Descripcion"))
                    
                    self.__Resultado[resultado.getId()]= resultado
                    WebService.MoveNext()
                return True
            else:
                raise Excepciones.Genericas.Consulta_Sin_Resultados(
                        "BuscarFabricantes"
                        , "Buscar"
                        , "No se encotraron Fabricantes")
                

    def Buscar(self):
        self.setPaginaActual(1)
        if self.__Buscar()== True:
            return self.__Resultado
        
    def BuscarPaginaSiguiente(self):
        if self.PuedeIrAPaginaSiguiente()== True:
            self.IrPaginaSiguiente()
            if self.__Buscar()== True:
                return self.__Resultado
            
    def BuscarPaginaAnterior(self):
        if self.PuedeIrAPaginaAnterior()== True:
            self.IrPaginaAnterior()
            if self.__Buscar()== True:
                return self.__Resultado
    def clear(self):
        self.__Resultado = {}
        self.__Nombre = ""
        self.__Descripcion = ""
    
    
class ResultadoFabricantes():
    def __init__(self,lid = -1,lnombre = "",ldescripcion = ""):
        self.__id = lid
        self.__Nombre = lnombre
        self.__Descripcion = ldescripcion
    def getId(self):
        return self.__id
    def getNombre(self):
        return self.__Nombre
    def getDescripcion(self):
        return self.__Descripcion
    def setNombre(self, value):
        self.__Nombre = value
    def setDescripcion(self, value):
        self.__Descripcion = value
    def setId(self,value):
        self.__id = value

                      
class ResultadoArticulo():
    def __init__(self,lsecurity = None):
        self.__Caracteristicas = {}
        self.__stockxdeposito = {}
        self.__security = lsecurity
        self.__Id = -1
        self.__TipoArticulo = ""
        self.__Modelo = ""
        self.__Fabricante = ""   
        self.__DescripcionArticulo = "" 
        self.__RequiereNroDeSerie = False  
        self.__StockMinimo = 0  
        self.__EnStock = 0
        self.__NivelStock = "Bajo"
        self.__Disponible = 0
    def getCaracteristicas(self):
        return self.__Caracteristicas
    def getStockxdeposito(self):
        return self.__stockxdeposito
    def setSecurity(self, value):
        self.__security = value
    def getEnStock(self):
        return self.__EnStock
    def getNivelStock(self):
        return self.__NivelStock
    def getDisponible(self):
        return self.__Disponible
    def setEnStock(self, value):
        self.__EnStock = value
    def setNivelStock(self, value):
        self.__NivelStock = value
    def setDisponible(self, value):
        self.__Disponible = value
    def getStockMinimo(self):
        return self.__StockMinimo
    def setStockMinimo(self, value):
        self.__StockMinimo = value
    def getRequiereNroDeSerie(self):
        return self.__RequiereNroDeSerie
    def setRequiereNroDeSerie(self, value):
        self.__RequiereNroDeSerie = value
    def getDescripcionArticulo(self):
        return self.__DescripcionArticulo
    def setDescripcionArticulo(self, value):
        self.__DescripcionArticulo = value
    def getId(self):
        return self.__Id
    def getTipoArticulo(self):
        return self.__TipoArticulo
    def getModelo(self):
        return self.__Modelo
    def getFabricante(self):
        return self.__Fabricante
    def setId(self, value):
        self.__Id = value
    def setTipoArticulo(self, value):
        self.__TipoArticulo = value
    def setModelo(self, value):
        self.__Modelo = value
    def setFabricante(self, value):
        self.__Fabricante = value
    def getCaracteristicas_str(self):
        lcaracteristicas = ""
        for key in self.__Caracteristicas:
            lcaracteristicas = lcaracteristicas + key + ": " + self.__Caracteristicas[key]+ ";"
        return lcaracteristicas
    def AgregarCaracteristica(self,lcara,lvalor):
        self.__Caracteristicas[lcara]= lvalor
    def Traer_Todas_Las_Caracteristicas(self):
        self.__Caracteristicas.clear()
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos())
        Parametros = {
                        1:('IdArticulo',str(self.getId()))
                        ,2:('TipoRespuesta','Python')
                    }
            
        if WebService.Enviar('SELECT_CaracteristicasDeArticulosXId'
                                ,'www.osplad.org.ar'
                                , Parametros) == True:
            if WebService.Count()!= 0 :
                while WebService.BOF()!= True and WebService.EOF()!= True:
                    self.AgregarCaracteristica(WebService.Fields("CARACTERISTICA")
                                               ,WebService.Fields("VALOR"))
                    WebService.MoveNext()
                return True
            else:
                return True
    def Traer_Stock_Por_Depositos(self):
        self.__stockxdeposito.clear()
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos())
        Parametros = {
                        1:('Id_Articulo',str(self.getId()))
                        ,2:('Id_GrupoStock',str(self.__security.getPerfilActual()))
                        ,3:('TipoRespuesta','Python')
                        }
            
        if WebService.Enviar('SELECT_Movimientos_CantDeArticuloEnStockxDepositos'
                                ,'www.osplad.org.ar'
                                , Parametros) == True:
            if WebService.Count()!= 0 :
                while WebService.BOF()!= True and WebService.EOF()!= True:
                    self.__stockxdeposito[WebService.Fields("Codigo")] = WebService.Fields("StockActual")                
                    WebService.MoveNext()
                return True
            else:
                return True

class ResultadoProveedor():
    def __init__(self):
        self.__Id = -1
        self.__Cuil = ""
        self.__Nombre = ""
        self.__RazonSocial = ""
        self.__Direccion = ""
        self.__Telefonos = ""
        self.__Localidad = ""
    def getCuil(self):
        return self.__Cuil
    def setCuil(self, value):
        self.__Cuil = value
    def getId(self):
        return self.__Id
    def getNombre(self):
        return self.__Nombre
    def getRazonSocial(self):
        return self.__RazonSocial
    def getDireccion(self):
        return self.__Direccion
    def getTelefonos(self):
        return self.__Telefonos
    def getLocalidad(self):
        return self.__Localidad
    def setId(self, value):
        self.__Id = value
    def setNombre(self, value):
        self.__Nombre = value
    def setRazonSocial(self, value):
        self.__RazonSocial = value
    def setDireccion(self, value):
        self.__Direccion = value
    def setTelefonos(self, value):
        self.__Telefonos = value
    def setLocalidad(self, value):
        self.__Localidad = value
        

        
#class ResultadoArticuloConCaracteristicas(ResultadoArticulo):
#    def __init__(self,lsecurity = None):
#        ResultadoArticulo.__init__(self)
#        self.__Caracteristicas = {}
#        self.__security = lsecurity
#    def getCaracteristicas_str(self):
#        lcaracteristicas = ""
#        for key in self.__Caracteristicas:
#            lcaracteristicas = lcaracteristicas + key + ": " + self.__Caracteristicas[key]+ ";"
#        return lcaracteristicas
#    def AgregarCaracteristica(self,lcara,lvalor):
#        self.__Caracteristicas[lcara]= lvalor
#    def Traer_Todas_Las_Caracteristicas(self):
#        self.__Caracteristicas.clear()
#        WebService = WebServices.soap.WebService(
#                    self.__security.getUrlServidorWeb()
#                    , self.__security.getHostServidorWeb()
#                    , self.__security.getProxy()
#                    , self.__security.getTipoServidor()
#                    ,self.__security.getReintentos())
#        Parametros = {
#                        1:('IdArticulo',str(self.getId()))
#                        ,2:('TipoRespuesta','Python')
#                    }
#            
#        if WebService.Enviar('SELECT_CaracteristicasDeArticulosXId'
#                                ,'www.osplad.org.ar'
#                                , Parametros) == True:
#            if WebService.Count()!= 0 :
#                while WebService.BOF()!= True and WebService.EOF()!= True:
#                    self.AgregarCaracteristica(WebService.Fields("CARACTERISTICA")
#                                               ,WebService.Fields("VALOR"))
#                    WebService.MoveNext()
#                return True
#            else:
#                return True